{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T02:28:16.573101Z",
     "start_time": "2025-03-06T02:28:14.334223Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.9.1\n",
      "numpy 2.0.0\n",
      "pandas 2.2.2\n",
      "sklearn 1.6.1\n",
      "torch 2.6.0+cu126\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载数据"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T02:28:17.569067Z",
     "start_time": "2025-03-06T02:28:16.574105Z"
    }
   },
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 当然也可以用 torch.utils.data.Dataset 实现人为划分\n",
    "# 从数据集到dataloader\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T02:28:21.485056Z",
     "start_time": "2025-03-06T02:28:17.570070Z"
    }
   },
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds: # 遍历每张图片,img.shape=[1,28,28]\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "print(cal_mean_std(train_ds))\n",
    "# 0.2860， 0.3205\n",
    "transforms = nn.Sequential(\n",
    "    Normalize([0.2860], [0.3205]) # 这里的均值和标准差是通过train_ds计算得到的\n",
    ")\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([0.2860]), tensor([0.3205]))\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型\n",
    "\n",
    "这里我们没有用`nn.Linear`的默认初始化，而是采用了xavier均匀分布去初始化全连接层的权重\n",
    "\n",
    "xavier初始化出自论文 《Understanding the difficulty of training deep feedforward neural networks》，适用于使用`tanh`和`sigmoid`激活函数的方法。当然，我们这里的模型采用的是`relu`激活函数，采用He初始化（何凯明初始化）会更加合适。感兴趣的同学可以自己动手修改并比对效果。\n",
    "\n",
    "|神经网络层数|初始化方式|early stop at epoch| val_loss | vla_acc|\n",
    "|-|-|-|-|-|\n",
    "|20|默认|\n",
    "|20|xaviier_uniform|\n",
    "|20|he_uniform|\n",
    "|...|\n",
    "\n",
    "He初始化出自论文 《Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification》"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T02:28:21.494060Z",
     "start_time": "2025-03-06T02:28:21.485056Z"
    }
   },
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, layers_num=2):\n",
    "        super().__init__()\n",
    "        self.transforms = transforms # 预处理层，标准化\n",
    "        self.flatten = nn.Flatten()\n",
    "        # 多加几层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        # 加19层:所谓的DNN就是多个全连接层堆叠而成\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"relu\", nn.ReLU())\n",
    "        # 输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "        \n",
    "        # 初始化权重\n",
    "        self.init_weights()\n",
    "        \n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层的权重 W\"\"\"\n",
    "        # print('''初始化权重''')\n",
    "        for m in self.modules():\n",
    "            # print(m)\n",
    "            # print('-'*50)\n",
    "            if isinstance(m, nn.Linear):#判断m是否为全连接层\n",
    "                # https://pytorch.org/docs/stable/nn.init.html\n",
    "                nn.init.xavier_uniform_(m.weight) # xavier 均匀分布初始化权重\n",
    "                nn.init.zeros_(m.bias) # 全零初始化偏置项\n",
    "        # print('''初始化权重完成''')\n",
    "    def forward(self, x):\n",
    "        # x.shape [batch size, 1, 28, 28]\n",
    "        x = self.transforms(x) #标准化\n",
    "        x = self.flatten(x)  \n",
    "        # 展平后 x.shape [batch size, 28 * 28]\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        # logits.shape [batch size, 10]\n",
    "        return logits\n",
    "total=0\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    # print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\") #np.prod是计算张量的元素个数\n",
    "    # print(f\"Linear_{idx // 2:>02}\\tshape: {value.shape}\")\n",
    "    total+=np.prod(value.shape)\n",
    "total #模型参数数量"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.int64(271410)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "code",
   "source": [
    "w = torch.empty(3, 5)\n",
    "print(w)\n",
    "nn.init.eye_(w)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-06T02:28:21.499563Z",
     "start_time": "2025-03-06T02:28:21.495064Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-1.2375e+01,  1.8890e-42,  0.0000e+00,  0.0000e+00,  0.0000e+00],\n",
      "        [ 0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00],\n",
      "        [ 0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00]])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([[1., 0., 0., 0., 0.],\n",
       "        [0., 1., 0., 0., 0.],\n",
       "        [0., 0., 1., 0., 0.]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 5
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T02:28:21.532392Z",
     "start_time": "2025-03-06T02:28:21.499563Z"
    }
   },
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "outputs": [],
   "execution_count": 6
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T02:28:23.634334Z",
     "start_time": "2025-03-06T02:28:21.532392Z"
    }
   },
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "outputs": [],
   "execution_count": 7
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T02:28:23.638366Z",
     "start_time": "2025-03-06T02:28:23.634334Z"
    }
   },
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 8
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T02:28:23.644905Z",
     "start_time": "2025-03-06T02:28:23.638366Z"
    }
   },
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "outputs": [],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T02:28:23.653148Z",
     "start_time": "2025-03-06T02:28:23.644905Z"
    }
   },
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                    \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 100\n",
    "\n",
    "model = NeuralNetwork(layers_num=10)\n"
   ],
   "outputs": [],
   "execution_count": 10
  },
  {
   "cell_type": "code",
   "source": [
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "tensorboard_callback = TensorBoardCallback(\"runs\")\n",
    "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
    "# 2. save best\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints\", save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10, min_delta=0.001)\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-06T02:28:23.797648Z",
     "start_time": "2025-03-06T02:28:23.653148Z"
    }
   },
   "outputs": [],
   "execution_count": 11
  },
  {
   "cell_type": "code",
   "source": [
    "record = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_loader)\n",
    "    )"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-06T02:37:41.588370Z",
     "start_time": "2025-03-06T02:28:23.797648Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "f87fc8e40f344b4d9d8149c358fef863"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 19 / global_step 71250\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T02:37:41.929035Z",
     "start_time": "2025-03-06T02:37:41.589375Z"
    }
   },
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(6 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10000)  #横坐标是 steps"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T02:37:44.519392Z",
     "start_time": "2025-03-06T02:37:41.931041Z"
    }
   },
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/best.ckpt\", weights_only=True,map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3690\n",
      "accuracy: 0.8831\n"
     ]
    }
   ],
   "execution_count": 14
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
